com.eignex.koblas/sparse/host/klu/[jvm]KluSparseLu

KluSparseLu

class KluSparseLu(val config: KluConfig = KluConfig()) : F64SparseLuAdapter(source)

Sparse LU factorizations backed by KLU 2.

Constructors

KluSparseLu

constructor(config: KluConfig = KluConfig())(source)

Properties

config

val config: KluConfig(source)

Policy for this backend instance.

name

open override val name: String(source)

A short backend identifier for diagnostics (e.g. "reference").

priority

open override val priority: Int(source)

Relative preference among the backends offered for one half (F64Blas, F64Decompositions, F64Kernels or a sparse counterpart). registerBackend picks the highest; the portable reference is 0.

isAvailable

open override val isAvailable: Boolean

Whether this backend can do work on this host. koblas's own implementations always can, so the default is true; a binding reports whether the library it calls resolved.

isPortable

open override val isPortable: Boolean

Whether this is koblas's own implementation rather than a binding to a host library. The compiled-in SIMD kernels are portable however fast they are; only something calling out counts as accelerated.

supportsBasisUpdates

open val supportsBasisUpdates: Boolean

Whether factorBasis answers with a factorization that updates its factors in place. When false a replacement costs a factorization, so a caller pacing its own refactorizations has nothing left to pace.

Functions

refactor

open override fun refactor(previous: F64SparseFactorization, a: F64SparseMatrix, equilibrate: Boolean = false, dropTolerance: Double = NO_DROP): F64SparseFactorization(source)

Factor a, reusing compatible state from previous when this backend can. The returned factorization supersedes previous, which must not be solved after this call. Backends that cannot reuse it answer as factor would.

factor

override fun factor(a: F64SparseMatrix, equilibrate: Boolean = false, dropTolerance: Double = NO_DROP): F64SparseFactorization

Factorize the square a into something solvable. A singular matrix comes back as a factorization reporting singular rather than as an exception, with a failedAt counting elimination steps rather than naming a column: the step that fails is the one with no acceptable pivot left, so there is no column of a to attribute it to.

factorBasis

open fun factorBasis(basis: F64SparseMatrix): F64BasisFactorization

Factor a simplex basis for column replacements.

solve

open fun solve(f: F64SparseFactorization, b: DoubleArray, transpose: Boolean = false): DoubleArray

solveInto into a fresh vector.

solveInto

open fun solveInto(f: F64SparseFactorization, b: DoubleArray, out: DoubleArray, transpose: Boolean = false, workspace: Workspace? = null): DoubleArray

Solve A·x = b from f into out, Aᵀ·x = b when transpose. The work belongs to the factorization; this is here so the seam reads the same from the sparse side as com.eignex.koblas .dense.F64Decompositions.solveInto does from the dense one.